Python Scope

பைத்தான் வரம்பு கற்றுக்கொள்ளுங்கள்

Python - வரம்பு

ஒரு மாறி அது உருவாக்கப்பட்ட பகுதியிலிருந்து மட்டுமே கிடைக்கும். இது வரம்பு என்று அழைக்கப்படுகிறது.

வரம்பு என்றால் என்ன?

வரம்பு கருத்து

வரையறை: மாறிகள் அணுகக்கூடிய பகுதி

முக்கியத்துவம்: மாறி மோதல்களைத் தவிர்க்கிறது

பைத்தான்: 4 வகையான வரம்புகள்

ஏன் வரம்பு தேவை?

பாதுகாப்பு: மாறிகள் தற்செயலாக மாறுவதைத் தடுக்கிறது

நினைவகம்: திறமையான நினைவக மேலாண்மை

தொகுதி: குறியீட்டைத் தனித்துப் பிரிக்கிறது

உள்ளூர் வரம்பு

ஒரு செயல்பாட்டிற்குள் உருவாக்கப்பட்ட மாறி அந்த செயல்பாட்டின் உள்ளூர் வரம்புக்கு சொந்தமானது, மேலும் அந்த செயல்பாட்டிற்குள் மட்டுமே பயன்படுத்த முடியும்.

🏁 உதவிக்குறிப்பு:

உள்ளூர் மாறிகள் செயல்பாடு முடிந்தவுடன் அழிக்கப்படுகின்றன. அவை செயல்பாட்டிற்கு வெளியே கிடைக்காது.

எடுத்துக்காட்டு

ஒரு செயல்பாட்டிற்குள் உருவாக்கப்பட்ட மாறி அந்த செயல்பாட்டிற்குள் கிடைக்கும்:

def myfunc():
    x = 300
    print(x)

myfunc()  # Output: 300

# பின்வரும் வரி பிழையை ஏற்படுத்தும்
# print(x)  # NameError: name 'x' is not defined

நினைவக பிரதிநிதித்துவம்:

myfunc() அழைக்கப்படும் போது: x உள்ளூர் மாறியாக உருவாக்கப்படுகிறது

myfunc() இன் உள்ளே: x அணுகக்கூடியது

myfunc() முடிந்த பிறகு: x அழிக்கப்படுகிறது

செயல்பாட்டிற்கு வெளியே: x வரையறுக்கப்படவில்லை

செயல்பாட்டிற்குள் செயல்பாடு

மேலே உள்ள எடுத்துக்காட்டில் விளக்கப்பட்டுள்ளபடி, மாறி x செயல்பாட்டிற்கு வெளியே கிடைக்காது, ஆனால் அது செயல்பாட்டிற்குள் உள்ள எந்த செயல்பாட்டிற்கும் கிடைக்கும்:

எடுத்துக்காட்டு

உள்ளூர் மாறியை செயல்பாட்டிற்குள் உள்ள செயல்பாட்டிலிருந்து அணுகலாம்:

def myfunc():
    x = 300
    
    def myinnerfunc():
        print(x)  # உள்ளே உள்ள செயல்பாடு x ஐ அணுகலாம்
    
    myinnerfunc()

myfunc()  # Output: 300

செயல்பாட்டு நிலைகள்

நிலை 1: myfunc() அழைக்கப்படுகிறது

நிலை 2: x = 300 உருவாக்கப்படுகிறது

நிலை 3: myinnerfunc() அழைக்கப்படுகிறது

நிலை 4: myinnerfunc() x ஐ அணுகுகிறது

நிலை 5: x அழிக்கப்படுகிறது

அணுகல் விதி

உள்ளே உள்ள செயல்பாடு: வெளியே உள்ள செயல்பாட்டின் மாறிகளைப் பார்க்க முடியும்

வெளியே உள்ள செயல்பாடு: உள்ளே உள்ள செயல்பாட்டின் மாறிகளைப் பார்க்க முடியாது

ஒரு தரிசனம்: உள்ளே இருந்து வெளியே பார்க்க முடியும், ஆனால் வெளியே இருந்து உள்ளே பார்க்க முடியாது

பெரும்பரப்பு வரம்பு

Python குறியீட்டின் முக்கிய உடலில் உருவாக்கப்பட்ட மாறி ஒரு பெரும்பரப்பு மாறி மற்றும் பெரும்பரப்பு வரம்புக்கு சொந்தமானது.

🌍 குறிப்பு:

பெரும்பரப்பு மாறிகள் எந்த வரம்பிலிருந்தும் கிடைக்கும், பெரும்பரப்பு மற்றும் உள்ளூர் இரண்டிலும்.

எடுத்துக்காட்டு

ஒரு செயல்பாட்டிற்கு வெளியே உருவாக்கப்பட்ட மாறி பெரும்பரப்பு மற்றும் யாராலும் பயன்படுத்தப்படலாம்:

x = 300  # பெரும்பரப்பு மாறி

def myfunc():
    print(x)  # செயல்பாடு பெரும்பரப்பு மாறியை அணுகலாம்

myfunc()  # Output: 300
print(x)  # Output: 300 (செயல்பாட்டிற்கு வெளியே அணுகலாம்)

மாறிகளுக்குப் பெயரிடுதல்

நீங்கள் ஒரு செயல்பாட்டிற்குள் மற்றும் வெளியே ஒரே மாறி பெயருடன் செயல்பட்டால், Python அவற்றை இரண்டு தனி மாறிகளாகக் கருதும், ஒன்று பெரும்பரப்பு வரம்பில் (செயல்பாட்டிற்கு வெளியே) கிடைக்கும் மற்றும் ஒன்று உள்ளூர் வரம்பில் (செயல்பாட்டிற்குள்) கிடைக்கும்:

எடுத்துக்காட்டு

செயல்பாடு உள்ளூர் x ஐ அச்சிடும், பின்னர் குறியீடு பெரும்பரப்பு x ஐ அச்சிடும்:

x = 300  # பெரும்பரப்பு x

def myfunc():
    x = 200  # உள்ளூர் x (பெரும்பரப்பு x இலிருந்து வேறுபட்டது)
    print("Inside function:", x)  # உள்ளூர் x ஐ அச்சிடுகிறது

myfunc()  # Output: Inside function: 200
print("Outside function:", x)  # Output: Outside function: 300

⚠️ முக்கிய வேறுபாடு:

செயல்பாட்டிற்குள் x = 200 ஒரு புதிய உள்ளூர் மாறியை உருவாக்குகிறது, இது பெரும்பரப்பு மாறி x ஐ மாற்றாது. இது "மறைத்தல்" என்று அழைக்கப்படுகிறது.

global முக்கியச்சொல்

நீங்கள் ஒரு பெரும்பரப்பு மாறியை உருவாக்க வேண்டும், ஆனால் உள்ளூர் வரம்பில் சிக்கியிருந்தால், global முக்கியச்சொல்லைப் பயன்படுத்தலாம்.

🔑 உதவிக்குறிப்பு:

global முக்கியச்சொல் மாறியை பெரும்பரப்பு வரம்பிற்குச் சொந்தமானதாக ஆக்குகிறது.

எடுத்துக்காட்டு 1: பெரும்பரப்பு மாறியை உருவாக்குதல்

def myfunc():
    global x  # x ஒரு பெரும்பரப்பு மாறி என்று அறிவிக்கிறது
    x = 300

myfunc()
print(x)  # Output: 300 (செயல்பாட்டிற்கு வெளியே கிடைக்கும்)

எடுத்துக்காட்டு 2: பெரும்பரப்பு மாறியை மாற்றுதல்

x = 300  # பெரும்பரப்பு மாறி

def myfunc():
    global x  # பெரும்பரப்பு x ஐ மாற்றுவதாக அறிவிக்கிறது
    x = 200   # பெரும்பரப்பு x ஐ மாற்றுகிறது

myfunc()
print(x)  # Output: 200 (பெரும்பரப்பு மாறி மாற்றப்பட்டது)

nonlocal முக்கியச்சொல்

nonlocal முக்கியச்சொல் உள்ளடங்கிய செயல்பாடுகளுக்குள் மாறிகளுடன் வேலை செய்யப் பயன்படுகிறது.

🔗 குறிப்பு:

nonlocal முக்கியச்சொல் மாறி வெளியே உள்ள செயல்பாட்டிற்கு சொந்தமானதாக ஆக்குகிறது.

எடுத்துக்காட்டு

def myfunc1():
    x = "Jane"  # வெளியே உள்ள செயல்பாட்டின் மாறி
    
    def myfunc2():
        nonlocal x  # வெளியே உள்ள செயல்பாட்டின் x ஐ மாற்றுவதாக அறிவிக்கிறது
        x = "hello"  # வெளியே உள்ள செயல்பாட்டின் x ஐ மாற்றுகிறது
    
    myfunc2()
    return x

print(myfunc1())  # Output: "hello"

global vs nonlocal

global: பெரும்பரப்பு மாறிகளுக்கு

nonlocal: உள்ளடங்கிய செயல்பாட்டு மாறிகளுக்கு

இலக்கு: global → தொகுதி நிலை

இலக்கு: nonlocal → உள்ளடங்கிய செயல்பாடு

படிநிலை

நிலை 1: பெரும்பரப்பு வரம்பு

நிலை 2: உள்ளடங்கிய வரம்பு

நிலை 3: உள்ளூர் வரம்பு

nonlocal: நிலை 3 இலிருந்து நிலை 2 க்கு

LEGB விதி

Python மாறி பெயர்களைத் தேடும்போது LEGB விதியைப் பின்பற்றுகிறது, மேலும் அவற்றை இந்த வரிசையில் தேடுகிறது:

வரிசை வரம்பு விளக்கம் எடுத்துக்காட்டு
1 Local தற்போதைய செயல்பாட்டிற்குள் def func(): x = 10
2 Enclosing உள்ளடங்கிய செயல்பாடுகளுக்குள் (உள்ளே இருந்து வெளியே) def outer(): x = 10; def inner():
3 Global தொகுதியின் மேல் நிலையில் x = 10 # தொகுதி நிலை
4 Built-in Python இன் உள்ளமைக்கப்பட்ட பெயர்வெளியில் print, len, str

எடுத்துக்காட்டு: LEGB விதியைப் புரிந்துகொள்வது

x = "global"  # பெரும்பரப்பு நிலை

def outer():
    x = "enclosing"  # உள்ளடங்கிய நிலை
    
    def inner():
        x = "local"  # உள்ளூர் நிலை
        print("Inner:", x)  # உள்ளூர் x ஐப் பயன்படுத்துகிறது
    
    inner()
    print("Outer:", x)  # உள்ளடங்கிய x ஐப் பயன்படுத்துகிறது

outer()
print("Global:", x)  # பெரும்பரப்பு x ஐப் பயன்படுத்துகிறது

LEGB தேடல் செயல்முறை:

inner() செயல்பாட்டில்:

  1. உள்ளூர்: x = "local" → கிடைக்கிறது → பயன்படுத்துகிறது

outer() செயல்பாட்டில்:

  1. உள்ளூர்: x இல்லை
  2. உள்ளடங்கிய: x = "enclosing" → கிடைக்கிறது → பயன்படுத்துகிறது

தொகுதி நிலையில்:

  1. உள்ளூர்: x இல்லை
  2. உள்ளடங்கிய: x இல்லை
  3. பெரும்பரப்பு: x = "global" → கிடைக்கிறது → பயன்படுத்துகிறது

வரம்பு காட்சிப்படுத்தல்

செயல்பாட்டு நிலைகள்

# பெரும்பரப்பு வரம்பு
global_var = "I'm global"

def outer():
    # உள்ளடங்கிய வரம்பு
    enclosing_var = "I'm enclosing"
    
    def inner():
        # உள்ளூர் வரம்பு
        local_var = "I'm local"
        print(local_var)
        print(enclosing_var)
        print(global_var)
    
    inner()
    # print(local_var)  # பிழை!

outer()
# print(enclosing_var)  # பிழை!

வரம்பு காட்சிப்படுத்தல்

பெரும்பரப்பு வரம்பு

global_var = "I'm global"

outer() - உள்ளடங்கிய வரம்பு

enclosing_var = "I'm enclosing"

inner() - உள்ளூர் வரம்பு

local_var = "I'm local"

← உள்ளே இருந்து வெளியே பார்க்க முடியும் →

← வெளியே இருந்து உள்ளே பார்க்க முடியாது →

பயிற்சி

பின்வரும் குறியீட்டைக் கவனியுங்கள்:

x = 300
def myfunc():
    x = 200
myfunc()
print(x)

அச்சிடப்பட்ட முடிவு என்னவாக இருக்கும்?

❓ பயிற்சி கேள்வி:

200
✗ தவறு! செயல்பாட்டிற்குள் x = 200 ஒரு புதிய உள்ளூர் மாறியை உருவாக்குகிறது, பெரும்பரப்பு x ஐ மாற்றாது. global முக்கியச்சொல் இல்லாமல், செயல்பாட்டு உள்ளே உள்ள x பெரும்பரப்பு x இலிருந்து வேறுபட்டது.
300
✓ சரி! செயல்பாடு ஒரு புதிய உள்ளூர் மாறி x ஐ உருவாக்குகிறது, இது பெரும்பரப்பு x ஐ மாற்றாது. print(x) பெரும்பரப்பு x ஐ அச்சிடுகிறது, இது மாறாமல் 300 ஆக உள்ளது.
200300
✗ தவறு! இந்த குறியீடு 200300 ஐ அச்சிடாது. செயல்பாடு x ஐ அச்சிடவில்லை, இது பெரும்பரப்பு x ஐ மட்டுமே அச்சிடுகிறது. மேலும், இது இரண்டு எண்களை இணைக்காது.

சிறந்த நடைமுறைகள்

உள்ளூர் மாறிகளை முன்னுரிமை அளிக்கவும்: பெரும்பரப்பு மாறிகளைக் காட்டிலும் உள்ளூர் மாறிகளைப் பயன்படுத்துங்கள்
பெரும்பரப்பு மாறிகளைக் குறைக்கவும்: பெரும்பரப்பு மாறிகளின் பயன்பாட்டைக் குறைக்க முயற்சிக்கவும்
global மற்றும் nonlocal ஐ கவனமாகப் பயன்படுத்தவும்: அவை குழப்பத்தை ஏற்படுத்தக்கூடும்
பெயர் மறைத்தலைத் தவிர்க்கவும்: வெவ்வேறு வரம்புகளில் ஒரே மாறி பெயர்களைப் பயன்படுத்த வேண்டாம்
செயல்பாடு வாதங்களைப் பயன்படுத்தவும்: செயல்பாட்டிற்குள் தரவை அனுப்ப வாதங்களைப் பயன்படுத்துங்கள்